home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / programm.ing / egem_200.lzh / EGEM.2_0 / SOURCE / GRAF.C < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-07  |  10.7 KB  |  510 lines
  1.  
  2. #include <time.h>
  3. #include "proto.h"
  4.  
  5. static void draw_rubber(int *);
  6.  
  7. static int mouse_index;
  8. static long last_mouse;
  9.  
  10. static MFORM mouse_form[4] = {
  11. { 7,7,1,0,1,
  12.   {0x03C0, 0x0FF0, 0x1FF8, 0x3FFC, 0x7FFE, 0x7FFE, 0xFFFF, 0xFFFF,
  13.    0xFFFF, 0xFFFF, 0x7FFE, 0x7FFE, 0x3FFC, 0x1FF8, 0x0FF0, 0x03C0},
  14.   {0x0000, 0x03C0, 0x0CF0, 0x10F8, 0x20FC, 0x20FC, 0x40FE, 0x40FE,
  15.    0x7F02, 0x7F02, 0x3F04, 0x3F04, 0x1F08, 0x0F30, 0x03C0, 0x0000}},
  16. { 7,7,1,0,1,
  17.   {0x03C0, 0x0FF0, 0x1FF8, 0x3FFC, 0x7FFE, 0x7FFE, 0xFFFF, 0xFFFF,
  18.    0xFFFF, 0xFFFF, 0x7FFE, 0x7FFE, 0x3FFC, 0x1FF8, 0x0FF0, 0x03C0},
  19.   {0x0000, 0x03C0, 0x0C30, 0x1008, 0x381C, 0x3C3C, 0x7E7E, 0x7FFE,
  20.    0x7FFE, 0x7E7E, 0x3C3C, 0x381C, 0x1008, 0x0C30, 0x03C0, 0x0000}},
  21. { 7,7,1,0,1,
  22.   {0x03C0, 0x0FF0, 0x1FF8, 0x3FFC, 0x7FFE, 0x7FFE, 0xFFFF, 0xFFFF,
  23.    0xFFFF, 0xFFFF, 0x7FFE, 0x7FFE, 0x3FFC, 0x1FF8, 0x0FF0, 0x03C0},
  24.   {0x0000, 0x03C0, 0x0F30, 0x1F08, 0x3F04, 0x3F04, 0x7F02, 0x7F02,
  25.    0x40FE, 0x40FE, 0x20FC, 0x20FC, 0x10F8, 0x0CF0, 0x03C0, 0x0000}},
  26. { 7,7,1,0,1,
  27.   {0x03C0, 0x0FF0, 0x1FF8, 0x3FFC, 0x7FFE, 0x7FFE, 0xFFFF, 0xFFFF,
  28.    0xFFFF, 0xFFFF, 0x7FFE, 0x7FFE, 0x3FFC, 0x1FF8, 0x0FF0, 0x03C0},
  29.   {0x0000, 0x03C0, 0x0FF0, 0x1FF8, 0x2FF4, 0x27E4, 0x43C2, 0x4182,
  30.    0x4182, 0x43C2, 0x27E4, 0x2FF4, 0x1FF8, 0x0FF0, 0x03C0, 0x0000}}};
  31.  
  32. void graf_busy_mouse(void)
  33. {
  34.     long time;
  35.  
  36.     if (((time=clock())-last_mouse)<20)
  37.         return;
  38.  
  39.     last_mouse = time;
  40.     graf_mouse(USER_DEF,&mouse_form[mouse_index++]);
  41.     mouse_index &= 3;
  42. }
  43.  
  44. void graf_rt_slidebox(SLINFO *sl,int obj,int double_click)
  45. {
  46.     XEVENT event;
  47.     reg DIAINFO *info = sl->sl_info;
  48.     reg OBJECT *ptree = info->di_tree;
  49.     reg OBJECT *ob_ptr = ptree+sl->sl_slider,*par_ptr = ptree+sl->sl_parent;
  50.     reg int pos,prev,max_pos,max_val;
  51.     reg long y;
  52.     int    top,start_x,start_y,delta,flag = FALSE,count,index,offset = 0;
  53.     boolean sl_mode;
  54.     GRECT par;
  55.  
  56.     if (info->di_flag<=CLOSED || info->di_win->iconified)
  57.         return;
  58.  
  59.     if (info->di_flag>=WINDOW)
  60.     {
  61.         GRECT area, list;
  62.  
  63.         wind_xget(info->di_win->handle,WF_FIRSTXYWH,&list.g_x,&list.g_y,&list.g_w,&list.g_h);
  64.         if (list.g_w>0 && list.g_h>0)
  65.         {
  66.             wind_xget(info->di_win->handle,WF_WORKXYWH,&area.g_x,&area.g_y,&area.g_w,&area.g_h);
  67.             top = rc_equal(&area,&list);
  68.         }
  69.         else
  70.             return;
  71.     }
  72.     else
  73.         top = TRUE;
  74.  
  75.     start_x = ob_ptr->ob_x;
  76.     start_y = ob_ptr->ob_y;
  77.  
  78.     max_val = max(sl->sl_max - sl->sl_page,0);
  79.     delta = max(sl->sl_page - 1,1);
  80.  
  81.     objc_offset(ptree,sl->sl_parent,&par.g_x,&par.g_y);
  82.     par.g_w = par_ptr->ob_width;
  83.     par.g_h = par_ptr->ob_height;
  84.  
  85.     if (sl->sl_vh)
  86.         max_pos = par_ptr->ob_height - ob_ptr->ob_height;
  87.     else
  88.         max_pos = par_ptr->ob_width - ob_ptr->ob_width;
  89.  
  90.     if (obj<0)
  91.     {
  92.         prev = pos = sl->sl_pos;
  93.  
  94.         switch (obj)
  95.         {
  96.         case SL_UP:
  97.             pos--;
  98.             break;
  99.         case SL_DOWN:
  100.             pos++;
  101.             break;
  102.         case SL_PG_UP:
  103.             pos -= delta;
  104.             break;
  105.         case SL_PG_DN:
  106.             pos += delta;
  107.             break;
  108.         case SL_START:
  109.             pos = 0;
  110.             break;
  111.         case SL_END:
  112.             pos = max_val;
  113.             break;
  114.         default:
  115.             return;
  116.         }
  117.  
  118.         goto _set_slider;
  119.     }
  120.     else if (obj==sl->sl_dec || obj==sl->sl_inc)
  121.     {
  122.         sl_mode = TRUE;
  123.         count = index = 0;
  124.         if (obj==sl->sl_dec)
  125.             sl->sl_dec = FAIL;
  126.         else
  127.             sl->sl_inc = FAIL;
  128.     }
  129.     else if (obj==sl->sl_slider)
  130.     {
  131.         _mouse_pos(&event.ev_mm1x, &event.ev_mm1y);
  132.         start_x -= event.ev_mm1x;
  133.         start_y -= event.ev_mm1y;
  134.         sl_mode = FAIL;
  135.         double_click = 0;
  136.     }
  137.     else
  138.     {
  139.         _mouse_pos(&start_x, &start_y);
  140.         sl_mode = FALSE;
  141.         double_click = 0;
  142.     }
  143.  
  144.     _beg_ctrl();
  145.  
  146.     event.ev_mflags    = MU_BUTTON|MU_TIMER;
  147.     event.ev_mbmask = 3;
  148.     event.ev_mbclicks = 1;
  149.     event.ev_mbstate = event.ev_mthicount = 0;
  150.     event.ev_mtlocount = sl->sl_speed;
  151.     event.ev_mtlast = 0;
  152.  
  153.     if (sl_mode==TRUE)
  154.         ob_draw_chg(info,obj,NULL,ptree[obj].ob_state | SELECTED,top);
  155.     else if (sl_mode==FALSE)
  156.     {
  157.         if (sl->sl_vh)
  158.         {
  159.             if (start_y<par.g_y + ob_ptr->ob_y)
  160.                 delta = -delta;
  161.         }
  162.         else if (start_x<(par.g_x+ob_ptr->ob_x))
  163.             delta = -delta;
  164.     }
  165.     else
  166.     {
  167.         event.ev_mflags = MU_BUTTON|MU_M1;
  168.         event.ev_mm1flags = event.ev_mm1width = event.ev_mm1height = 1;
  169.  
  170.         graf_mouse (FLAT_HAND,NULL);
  171.     }
  172.  
  173.     if (sl_mode>=FALSE)
  174.         Event_Timer(sl->sl_delay,0);
  175.  
  176.     do
  177.     {
  178.         if (sl_mode>=FALSE && sl->sl_mode==SL_LOG)
  179.         {
  180.             count++;
  181.             event.ev_mtlocount = sl->sl_speed/count;
  182.         }
  183.  
  184.         flag = Event_Multi(&event) & MU_BUTTON;
  185.         event.ev_mm1x = event.ev_mmox;
  186.         event.ev_mm1y = event.ev_mmoy;
  187.  
  188.         if (max_pos>0)
  189.         {
  190.             prev = sl->sl_pos;
  191.  
  192.             if (sl_mode==TRUE)
  193.             {
  194.                 if (double_click)
  195.                 {
  196.                     if (sl->sl_dec<0)
  197.                         pos = 0;
  198.                     else
  199.                         pos = max_val;
  200.                     flag = TRUE;
  201.                 }
  202.                 else
  203.                 {
  204.                     switch (sl->sl_mode)
  205.                     {
  206.                     case SL_EXP:
  207.                         offset += ++index;
  208.                         break;
  209.                     case SL_LOG:
  210.                         offset = ++index;
  211.                         break;
  212.                     case SL_STEP:
  213.                         flag = TRUE;
  214.                     default:
  215.                         offset = 1;
  216.                     }
  217.  
  218.                     if (sl->sl_dec<0)
  219.                         pos = prev - offset;
  220.                     else
  221.                         pos = prev + offset;
  222.  
  223.                     if (pos<0 || pos>max_val)
  224.                         flag = TRUE;
  225.                 }
  226.             }
  227.             else if (sl_mode==FAIL)
  228.             {
  229.                 if (sl->sl_vh)
  230.                     pos = start_y + event.ev_mm1y;
  231.                 else
  232.                     pos = start_x + event.ev_mm1x;
  233.                 y = pos; y *= max_val; y /= max_pos;
  234.                 pos = (int) y;
  235.             }
  236.             else
  237.                 pos = prev + delta;
  238.  
  239.             _set_slider:
  240.             pos = min(max(pos,0),max_val);
  241.  
  242.             if (pos!=prev)
  243.             {
  244.                 reg GRECT area = par;
  245.                 reg int dif,n_pos,n_prev;
  246.  
  247.                 sl->sl_pos = pos;
  248.  
  249.                 y = pos;y *= max_pos;y /= max_val;
  250.                 n_pos = (int) y;
  251.  
  252.                 y = prev;y *= max_pos;y /= max_val;
  253.                 n_prev = (int) y;
  254.  
  255.                 dif = (n_pos < n_prev) ? (n_prev - n_pos + 1) : (n_pos - n_prev + 1);
  256.  
  257.                 if (sl->sl_vh)
  258.                 {
  259.                     area.g_h = dif;
  260.                     if (n_pos<n_prev)
  261.                         area.g_y += n_pos + ob_ptr->ob_height;
  262.                     else
  263.                         area.g_y += n_prev - 1;
  264.                     ob_ptr->ob_y = n_pos;
  265.                 }
  266.                 else
  267.                 {
  268.                     area.g_w = dif;
  269.                     if (n_pos<n_prev)
  270.                         area.g_x += n_pos + ob_ptr->ob_width;
  271.                     else
  272.                         area.g_x += n_prev - 1;
  273.                     ob_ptr->ob_x = n_pos;
  274.                 }
  275.  
  276.                 if (sl->sl_do)
  277.                     sl->sl_do(ob_ptr,pos,prev,max_val,top);
  278.  
  279.                 ob_draw_chg(info,sl->sl_slider,NULL,FAIL,top);
  280.                 ob_draw_chg(info,sl->sl_parent,&area,FAIL,top);
  281.  
  282.                 graf_set_slider(sl,ptree,GRAF_SET_ARROWS|GRAF_DRAW_SLIDER);
  283.             }
  284.  
  285.             if (obj<0)
  286.                 return;
  287.         }
  288.     } while (flag==FALSE);
  289.  
  290.     if (sl_mode==TRUE)
  291.     {
  292.         if (sl->sl_dec<0)
  293.             sl->sl_dec = obj;
  294.         else
  295.             sl->sl_inc = obj;
  296.         ob_draw_chg(info,obj,NULL,ptree[obj].ob_state & (~SELECTED),top);
  297.         graf_set_slider(sl,ptree,GRAF_SET_ARROWS|GRAF_DRAW_SLIDER);
  298.     }
  299.     else
  300.         graf_mouse(ARROW, NULL);
  301.  
  302.     _no_click();
  303.     _end_ctrl();
  304. }
  305.  
  306. void graf_arrows(SLINFO *sl,OBJECT *tree,int show)
  307. {
  308.     graf_set_slider(sl,tree,(show) ? (GRAF_SET_ARROWS|GRAF_DRAW_SLIDER) : GRAF_SET_ARROWS);
  309. }
  310.  
  311. void graf_set_slider(SLINFO *sl,OBJECT *tree,int show)
  312. {
  313.     reg OBJECT *ob_ptr;
  314.  
  315.     if (sl->sl_info->di_flag==CLOSED)
  316.         show &= ~GRAF_DRAW_SLIDER;
  317.  
  318.     if (show & GRAF_SET_SIZE_POS)
  319.     {
  320.         reg OBJECT *par_ptr;
  321.         reg long y = sl->sl_pos,size;
  322.         reg int vh = sl->sl_vh,max_val = sl->sl_max - sl->sl_page;
  323.  
  324.         par_ptr = tree+sl->sl_parent;
  325.         ob_ptr = tree+sl->sl_slider;
  326.  
  327.         if (sl->sl_page>1)
  328.         {
  329.             size = (vh==VERT_SLIDER) ? par_ptr->ob_height : par_ptr->ob_width;
  330.  
  331.             if (max_val>0)
  332.             {
  333.                 size *= sl->sl_page;
  334.                 size /= sl->sl_max;
  335.             }
  336.             else if (vh==VERT_SLIDER)
  337.                 ob_ptr->ob_y = 0;
  338.             else
  339.                 ob_ptr->ob_x = 0;
  340.         }
  341.         else
  342.             size = (vh==VERT_SLIDER) ? ob_ptr->ob_height : ob_ptr->ob_width;
  343.  
  344.         if (size<gr_ch)
  345.             size = gr_ch;
  346.  
  347.         if (vh==VERT_SLIDER)
  348.         {
  349.             ob_ptr->ob_height = (int) size;
  350.  
  351.             if (max_val>0)
  352.             {
  353.                 y *= (par_ptr->ob_height - (int) size);
  354.                 y /= max_val;
  355.                 ob_ptr->ob_y = (int) y;
  356.             }
  357.         }
  358.         else
  359.         {
  360.             ob_ptr->ob_width = (int) size;
  361.  
  362.             if (max_val>0)
  363.             {
  364.                 y *= (par_ptr->ob_width - (int) size);
  365.                 y /= max_val;
  366.                 ob_ptr->ob_x = (int) y;
  367.             }
  368.         }
  369.  
  370.         if (show & GRAF_DRAW_SLIDER)
  371.             ob_draw_chg(sl->sl_info,sl->sl_parent,NULL,FAIL,FALSE);
  372.     }
  373.  
  374.     if (show & GRAF_SET_ARROWS)
  375.     {
  376.         if (sl->sl_dec>0)
  377.         {
  378.             reg int state;
  379.  
  380.             ob_ptr = tree+sl->sl_dec;
  381.             state = ob_ptr->ob_state;
  382.  
  383.             if (sl->sl_pos>0)
  384.                 state &= ~DISABLED;
  385.             else
  386.                 state |= DISABLED;
  387.  
  388.             if (state!=ob_ptr->ob_state)
  389.             {
  390.                 ob_ptr->ob_state = state;
  391.  
  392.                 if (show & GRAF_DRAW_SLIDER)
  393.                     ob_draw_chg(sl->sl_info,sl->sl_dec,NULL,FAIL,FALSE);
  394.             }
  395.         }
  396.  
  397.         if (sl->sl_inc>0)
  398.         {
  399.             reg int state;
  400.  
  401.             ob_ptr = tree+sl->sl_inc;
  402.             state = ob_ptr->ob_state;
  403.  
  404.             if (sl->sl_pos<(sl->sl_max - sl->sl_page))
  405.                 state &= ~DISABLED;
  406.             else
  407.                 state |= DISABLED;
  408.  
  409.             if (state!=ob_ptr->ob_state)
  410.             {
  411.                 ob_ptr->ob_state = state;
  412.  
  413.                 if (show & GRAF_DRAW_SLIDER)
  414.                     ob_draw_chg(sl->sl_info,sl->sl_inc,NULL,FAIL,FALSE);
  415.             }
  416.         }
  417.     }
  418. }
  419.  
  420. int graf_rt_rubberbox(int s_x,int s_y,GRECT *rect,int *r_w,int *r_h,void (*call_func)(int *new_rect))
  421. {
  422.     XEVENT event;
  423.     reg int pxy[4],rect_xy[4];
  424.     reg int events,max_1,max_2,dif;
  425.  
  426.     if (!rc_inside(s_x,s_y,rect))
  427.         return(FALSE);
  428.  
  429.     rc_grect_to_array(rect,rect_xy);
  430.  
  431.     pxy[0] = s_x;
  432.     pxy[1] = s_y;
  433.  
  434.     max_1 = min(s_x - rect_xy[0],s_y - rect_xy[1]);
  435.     max_2 = min(rect_xy[2] - s_x,rect_xy[3] - s_y);
  436.  
  437.     _vdi_attr(MD_XOR,1,1);
  438.     vsl_type(x_handle,7);
  439.  
  440.     _beg_ctrl();
  441.     graf_mouse(POINT_HAND,NULL);
  442.  
  443.     event.ev_mflags = MU_BUTTON|MU_M1;
  444.     event.ev_mbclicks = event.ev_mm1flags = event.ev_mm1width = event.ev_mm1height = event.ev_mmokstate = 1;
  445.     event.ev_mbstate = 0;
  446.     event.ev_bmask = 3;
  447.  
  448.     _mouse_pos(&event.ev_mm1x,&event.ev_mm1y);
  449.  
  450.     do
  451.     {
  452.         pxy[2] = max(event.ev_mm1x,rect_xy[0]);
  453.         Min(pxy+2,rect_xy[2]);
  454.  
  455.         pxy[3] = max(event.ev_mm1y,rect_xy[1]);
  456.         Min(pxy+3,rect_xy[3]);
  457.  
  458.         if (event.ev_mmokstate)
  459.         {
  460.             dif = pxy[2] - pxy[0];
  461.             dif = (dif>0) ? min(dif,max_2) : max(dif,-max_1);
  462.             pxy[2] = pxy[0] + dif;
  463.             pxy[3] = pxy[1] + dif;
  464.         }
  465.  
  466.         draw_rubber(pxy);
  467.  
  468.         if (call_func)
  469.             call_func(pxy);
  470.  
  471.         events = Event_Multi(&event);
  472.         if (events & MU_M1)
  473.         {
  474.             event.ev_mm1x = event.ev_mmox;
  475.             event.ev_mm1y = event.ev_mmoy;
  476.         }
  477.  
  478.         draw_rubber(pxy);
  479.     }
  480.     while(!(events & MU_BUTTON));
  481.  
  482.     vsl_udsty(x_handle,0x5555);
  483.     vsl_type(x_handle,1);
  484.  
  485.     graf_mouse(ARROW,NULL);
  486.     _end_ctrl();
  487.  
  488.     *r_w = pxy[2] - pxy[0];
  489.     *r_h = pxy[3] - pxy[1];
  490.  
  491.     return(TRUE);
  492. }
  493.  
  494. static void draw_rubber(reg int *pxy)
  495. {
  496.     graf_mouse(M_OFF,0l);
  497.     vsl_udsty(x_handle,(pxy[0] & 1) == (pxy[1] & 1) ? 21845 : (int) 43690L);
  498.     _line(pxy[0],pxy[1],pxy[0],pxy[3]);
  499.  
  500.     vsl_udsty(x_handle,(pxy[2] & 1) == (pxy[1] & 1) ? 21845 : (int) 43690L);
  501.     _line(pxy[2],pxy[1],pxy[2],pxy[3]);
  502.  
  503.     vsl_udsty(x_handle,(pxy[1] & 1) ? (int) 43690L : 21845);
  504.     _line(pxy[0],pxy[1],pxy[2],pxy[1]);
  505.  
  506.     vsl_udsty(x_handle,(pxy[3] & 1) ? (int) 43690L : 21845);
  507.     _line(pxy[0],pxy[3],pxy[2],pxy[3]);
  508.     graf_mouse(M_ON,0l);
  509. }
  510.